package cn.itcast.service.impl;

import cn.itcast.dao.MenuDao;
import cn.itcast.dao.PermissionDao;
import cn.itcast.dao.RoleDao;
import cn.itcast.dao.UserDao;
import cn.itcast.entity.PageResult;
import cn.itcast.entity.QueryPageBean;
import cn.itcast.pojo.Menu;
import cn.itcast.pojo.Permission;
import cn.itcast.pojo.Role;
import cn.itcast.pojo.User;
import cn.itcast.service.UserService;
import cn.itcast.utils.MD5Utils;
import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;


@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private RoleDao roleDao;

    @Autowired
    private PermissionDao permissionDao;

    @Autowired
    private MenuDao menuDao;

    /**
     * 查询用户管理列表
     * @param queryPageBean 查询条件
     * @return
     */
    @Override
    public PageResult findPage(QueryPageBean queryPageBean) {
        //开启分页查询
        PageHelper.startPage(queryPageBean.getCurrentPage(), queryPageBean.getPageSize());
        //根据条件分页查询检查项信息
        Page<User> page = userDao.findPage(queryPageBean.getQueryString());

        //构建分页数据返回
        return new PageResult(page.getTotal(), page.getResult());
    }



    /**
     * 新增用户
     * @param user 用户信息
     * @return
     */
    @Override
    public Boolean handleAdd(int[] roleIds, User user) {
        //查询当前用户是否存在于数据库中
        User user1 = userDao.findByUsername(user.getUsername());
        //查询到数据，则直接返回
        if (user1 != null){
            return false;
        }
        //将密码进行MD5加密
        user.setPassword(MD5Utils.md5(user.getPassword()));
        int result = userDao.handleAdd(user);
        if (result == 1 && roleIds.length > 0){
            for (int i = 0; i < roleIds.length; i++) {
                //将用户对应的角色添加到t_user_role表中
                result = userDao.addToUserRole(user.getId(), roleIds[i]);
            }
        }
        return result > 0;
    }


    /**
     * 根据id查询用户信息
     * @param id 用户id
     * @return
     */
    @Override
    public User findUserById(Integer id) {
        return userDao.findUserById(id);
    }

    /**
     * 根据id查询用户角色
     * @param id 用户id
     * @return
     */
    @Override
    public List<Integer> findRoleById(Integer id) {
        //根据用户id到t_user_role表中查询角色id
        return userDao.findRoleList(id);
    }

    /**
     * 编辑用户
     * @param roleIds 角色id集合
     * @param user 用户信息
     * @return
     */
    @Override
    public Boolean handleEdit(int[] roleIds, User user) {
        //查询当前用户是否存在于数据库中
        User user1 = userDao.findByUsername(user.getUsername());
        //查询到数据，则直接返回
        if (user1 != null){
            return false;
        }
        //将密码进行MD5加密
        user.setPassword(MD5Utils.md5(user.getPassword()));
        //通过当前用户id， 删除t_user_role表中的数据
        int result = userDao.deleteById(user.getId());
        if (result > 0){
            //从新添加数据到t_user_role表中
            for (int i = 0; i < roleIds.length; i++) {
                //将用户对应的角色添加到t_user_role表中
                userDao.addToUserRole(user.getId(), roleIds[i]);
            }
        }
        //将用户信息跟新到数据库中
        int result1 = userDao.handleUpdate(user);

        return result1 > 0;
    }

    /**
     * 根据id删除用户
     * @param id  用户id
     * @return
     */
    @Override
    public Boolean handleDelete(Integer id) {
        //先删除t_user_role表中的数据
        int result = userDao.deleteById(id);

            //根据用户id删除user表中的数据
         result = userDao.deleteUserById(id);

        return result > 0;
    }






    /**
     * 根据用户名查询数据库中的用户信息，还需要查询用户关联的角色以及角色关联的权限
     * @param username
     * @return
     */
    @Override
    public User findByUsername(String username) {
        System.out.println("roleDao ======" + roleDao);
        User user = userDao.findByUsername(username);
        if (user == null) {
            return null;
        }
        Integer userId = user.getId();
        //根据用户id查询  t_user_role 表，获取当前用户的所有角色id
        List<Integer> roleList = userDao.findRoleList(userId);

        Set<Role> roles = new HashSet<>();
        //遍历角色id，查询所有的角色
        for (Integer integer : roleList) {
            Role role = roleDao.findById(integer);
            //将角色添加到set集合中
            roles.add(role);
        }

        //Set<Role> roles = roleDao.findByUserId(userId);
        // 遍历角色，查询对应的权限
        if (roles != null && roles.size() > 0) {
            for (Role role : roles) {
                //获取角色id
                Integer roleId = role.getId();
                //通过角色id，到表 t_role_permission 中查询当前角色具有的所有权限id集合
                List<Integer> permissionById = roleDao.findPermissionById(roleId);

                Set<Permission> permissions = new HashSet<>();

                //遍历权限id集合，获取权限详细信息
                for (Integer integer : permissionById) {
                    Permission permission = permissionDao.findById(integer);
                    //将权限添加到 set集合中
                    permissions.add(permission);
                }

                //Set<Permission> permissions = permissionDao.findByRoleId(roleId);
                if (permissions != null && permissions.size() > 0) {
                    role.setPermissions(permissions);
                }



                //通过角色id，到表 t_role_menu 中查询当前角色具有的所有菜单id
                List<Integer> menuById = roleDao.findMenuById(roleId);
                LinkedHashSet<Menu> menus = new LinkedHashSet<>();

                //遍历菜单id集合，获取菜单详细信息
                for (Integer integer : menuById) {
                    Menu menu = menuDao.findById(integer);
                    //将菜单添加到 set集合中
                    menus.add(menu);
                }

                if (menus != null && menus.size() > 0) {
                    role.setMenus(menus);
                }

            }
            user.setRoles(roles);
        }
        return user;
    }




    @Override
    public List<String> findRoleByUsername(String username) {
        return userDao.findRoleByUsername(username);
    }

    @Override
    public List<String> findPermissionByUsername(String username) {
        return userDao.findPermissionByUsername(username);
    }

    @Override
    public User findUserByUsername(String username) {
        return userDao.findUserByUsername(username);
    }

}
